package Underworld_Survival;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

import static Underworld_Survival.Game.gameOutput;
import static Underworld_Survival.GameOutput.*;

abstract class Skill implements Serializable {
    private transient String skillName;//技能名称
    private transient String skillEffect;//技能效果
    private transient int consumeAgi;//技能消耗的能量值
    private transient boolean isSingleTarget;//单体技能
    private transient ApplySkillEffect skill;
    public abstract String getSkillId();

    public Skill(){}
    public Skill(String skillName, String skillEffect, int consumeAgi, boolean isSingleTarget, ApplySkillEffect skill) {
        this.skillName = skillName;
        this.skillEffect = skillEffect;
        this.consumeAgi = consumeAgi;
        this.isSingleTarget = isSingleTarget;
        this.skill = skill;
    }

    //触发技能效果
    public void applyEffect(BattleManager battleCtx) {
        skill.applyEffect(battleCtx);
    }

    //getter,setter
    public String getSkillName() {return skillName;}
    public void setSkillName(String skillName) {this.skillName = skillName;}
    public String getSkillEffect() {return skillEffect;}
    public void setSkillEffect(String skillEffect) {this.skillEffect = skillEffect;}
    public int getConsumeAgi() {return consumeAgi;}
    public void setConsumeAgi(int consumeAgi) {this.consumeAgi = consumeAgi;}
    public ApplySkillEffect getSkill() {return skill;}
    public void setSkill(ApplySkillEffect skill) {this.skill = skill;}
    public boolean isIsSingleTarget() {return isSingleTarget;}
    public void setIsSingleTarget(boolean isSingleTarget) {this.isSingleTarget = isSingleTarget;}


}

//全局技能列表

//单体技能
//1.绝地反击desperate_counterattack
class desperate_counterattack extends Skill{
    public desperate_counterattack(){
        super("绝地反击", "造成力量的0.8倍伤害(能量不足时自动释放)", 0,true,
            battleCtx -> {
                Role attacker = battleCtx.getAttacker();//获取攻击者
                Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                if(target!=null){
                    int damage=((int) (attacker.getTotalStr() * 0.8 - target.getTotalDef())) < 1 ?
                            1 : ((int) (attacker.getTotalStr() * 0.8 - target.getTotalDef()));
                    gameOutput.println(MsgType.BATTLE,"能量不足！采取绝地反击，给" + target.getName() + "一击。");
                    if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                        println(MsgType.IMPORTANT,"* 暴击 *");
                        damage=(int)(damage*attacker.getTotalCritMultiplier());}//原伤害乘以暴击效果
                    battleCtx.setInjuryValue(damage);
                }else{
                    println(MsgType.WARNING,"！！！敌人列表为空！！！");
                }
            }
        );
    }

    @Override
    public String getSkillId() { return "skill_desperate_counterattack"; }

}
//2.普通攻击normalAttack
class normalAttack extends Skill{
    public normalAttack(){
        super("普通攻击", "造成力量的1倍伤害", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (attacker.getTotalStr() * 1 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalStr() * 1 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_normalAttack"; }

}
//3.无影脚shadowlessKick
class shadowlessKick extends Skill{
    public shadowlessKick(){
        super("无影脚", "造成速度的2.7倍伤害", 5,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (attacker.getTotalEP() * 2.7 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalEP() * 2.7 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_shadowlessKick"; }

}
//4.泰山压顶overwhelmingSmash
class overwhelmingSmash extends Skill{
    public overwhelmingSmash(){
        super("泰山压顶", "造成防御2.8倍伤害", 5,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (attacker.getTotalDef() * 2.8 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalDef() * 2.8 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_overwhelmingSmash"; }

}
//5.铁头功ironHeadSkill
class ironHeadSkill extends Skill{
    public ironHeadSkill(){
        super("铁头功", "造成力量的1.6倍伤害", 5,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (attacker.getTotalStr() * 1.6 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalStr() * 1.6 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_ironHeadSkill"; }

}
//6.降龙十八掌eighteenDragon_SubduingPalms
class eighteenDragon_SubduingPalms extends Skill{
    public eighteenDragon_SubduingPalms(){
        super("降龙十八掌", "造成力量的2.1倍伤害", 10,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (attacker.getTotalStr() * 2.1 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalStr() * 2.1 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_eighteenDragon_SubduingPalms"; }

}
//7.旋风腿cycloneKick
class cycloneKick extends Skill{
    public cycloneKick(){
        super("旋风腿", "造成速度的3.4倍伤害", 10,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (attacker.getTotalEP() * 3.4 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalEP() * 3.4 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_cycloneKick"; }

}
//8.剧毒爪poisonousClaw
class poisonousClaw extends Skill{
    public poisonousClaw(){
        super("剧毒爪", "无视防御，造成敌人最大生命值的30%伤害,一定几率让敌人【中毒】", 15,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (target.getTotalMaxHP() * 0.3)) < 1 ?
                                1 : ((int) (target.getTotalMaxHP() * 0.3));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        if(Math.random()<0.1){//让敌人【中毒】buff
                            println(MsgType.DECREASE,"毒气入侵，剧毒爪发挥作用"+target.getName()+"中毒了");
                            target.addBuff(new poison());
                        }
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_poisonousClaw"; }

}
//9.金刚护体invincibleBodyDefense
class invincibleBodyDefense extends Skill{
    public invincibleBodyDefense(){
        super("金刚护体", "一回合【无敌】,免疫敌人一次攻击，并获得持续4回合的【金刚】", 25,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    attacker.addBuff(new indomitable());//获取无敌buff
                    attacker.addBuff(new adamant());//获取金刚buff
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_invincibleBodyDefense"; }

}
//10.敏捷突袭agileSurge
class agileSurge extends Skill{
    public agileSurge(){
        super("敏捷突袭", "造成速度的2倍伤害", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (attacker.getTotalEP() * 2 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalEP() * 2 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_agileSurge"; }

}
//11.晶化蛛网crystallizedCobweb
class crystallizedCobweb extends Skill{
    public crystallizedCobweb(){
        super("晶化蛛网", "造成力量的1.5倍伤害", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (attacker.getTotalStr() * 1.5 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalStr() * 1.5 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_crystallizedCobweb"; }

}
//12.召唤晶簇summonCrystalCluster
class summonCrystalCluster extends Skill{
    public summonCrystalCluster(){
        super("召唤晶簇", "造成固定25点伤害", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=25;
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_summonCrystalCluster"; }

}
//13.毒牙诅咒poisonFangCurse
class poisonFangCurse extends Skill{
    public poisonFangCurse(){
        super("毒牙诅咒", "无视防御，造成对手最大生命值的10%，并附带10点固定伤害,概率【诅咒】敌人", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage = (int) (target.getTotalMaxHP() * 0.1) + 10;
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        if(Math.random()<0.3){
                            System.out.println("咒语生效，"+target.getName()+"被诅咒了");
                            target.addBuff(new curse());//获取诅咒buff
                        }
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_poisonFangCurse"; }

}
//14.残像斩afterimageSlash
class afterimageSlash extends Skill{
    public afterimageSlash(){
        super("残像斩", "造成力量的2倍伤害", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (attacker.getTotalStr() * 2 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalStr() * 2 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_afterimageSlash"; }

}
//15.剑意反弹sword_QiRebound(敌人专属技能，能够提升属性)
class sword_QiRebound extends Skill{
    public sword_QiRebound(){
        super("剑意反弹", "造成力量的1.5倍伤害,并提升自己2点力量值，2点速度值", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (attacker.getTotalStr() * 1.5 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalStr() * 1.5 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                        attacker.modifyAttributes(Map.of(AttributeType.BONUS_STR,2f,
                                AttributeType.BONUS_EP,2f),true);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_sword_QiRebound"; }

}
//16.生命虹吸lifeSiphon
class lifeSiphon extends Skill{
    public lifeSiphon(){
        super("生命虹吸", "吸取对手最大生命值15%，造成伤害，并恢复自身", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage = (int) (target.getTotalMaxHP() * 0.15);
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        attacker.refillHP(damage);
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_lifeSiphon"; }

}
//17.黑暗恢复darkRecovery
class darkRecovery extends Skill{
    public darkRecovery(){
        super("黑暗恢复", "恢复自身最大生命值25%,有一定概率获得buff【焕生】", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    attacker.refillHP((int)(attacker.getTotalMaxHP()*0.25));
                    if(Math.random()<0.5){
                        attacker.addBuff(new revitalize());
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_darkRecovery"; }

}
//18.岩浆护甲magmaArmor
class magmaArmor extends Skill{
    public magmaArmor(){
        super("岩浆护甲", "让敌人【灼烧】，并获得持续4回合的【金刚】", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    attacker.addBuff(new adamant());//获取金刚buff
                    target.addBuff(new burning());
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_magmaArmor"; }

}
//19.地裂猛击earth_SplittingSmash
class earth_SplittingSmash extends Skill{
    public earth_SplittingSmash(){
        super("地裂猛击", "造成防御的2倍伤害", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (attacker.getTotalDef() * 2 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalDef() * 2 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_earth_SplittingSmash"; }

}
//20.末日喷发doomsdayEruption
class doomsdayEruption extends Skill{
    public doomsdayEruption(){
        super("末日喷发", "造成力量的2倍伤害，一定概率让自己【沸血】", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者列表，单体技能一个，群体技能所有活着的敌人
                    if(target!=null){
                        int damage=((int) (attacker.getTotalStr() * 2 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalStr() * 2 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        if(Math.random()<0.3){//概率获得【沸血】buff
                            println(MsgType.INCREASE,"啊！烧起来，都烧起来！");
                            attacker.addBuff(new boilingBlood());//获得buff【沸血】
                        }
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_doomsdayEruption"; }

}

//群体技能
//1.万剑归宗convergenceOfBlades(介绍：破碎与重生的轮回，在万剑共鸣中化作最终审判)
class convergenceOfBlades extends Skill{
    public convergenceOfBlades(){
        super("万剑归宗", "对所有目标造成力量的1.5倍伤害", 15,false,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    Role target = battleCtx.getTarget();//被攻击者
                    if(target!=null){
                        int damage=((int) (attacker.getTotalStr() * 1.5 - target.getTotalDef())) < 1 ?
                                1 : ((int) (attacker.getTotalStr() * 1.5 - target.getTotalDef()));
                        if(Math.random()<attacker.getTotalCritRate()){//是否暴击，Math.random生成的数是0-1
                            println(MsgType.IMPORTANT,"* 暴击 *");
                            damage=(int)(damage*attacker.getTotalCritMultiplier());}
                        battleCtx.setInjuryValue(damage);
                    }else{
                        println(MsgType.WARNING,"！！！敌人列表为空！！！");
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_convergenceOfBlades"; }


}

//召唤技能
//1.无尽兵锋endlessEdgeOfSpear
class endlessEdgeOfSpear extends Skill{
    public endlessEdgeOfSpear(){
        super("无尽兵锋", "召唤一只小骨兵,有一定概率获得buff【沸血】", 0,true,
                battleCtx -> {
                    Role attacker = battleCtx.getAttacker();//获取攻击者
                    battleCtx.getLivingEnemy().add(new little_BoneSoldier());
                    gameOutput.println(MsgType.BATTLE,"一只小骨兵加入战场！");
                    if(Math.random()<0.3){
                        gameOutput.println(MsgType.BATTLE,"我要把你们统统毁灭！");
                        attacker.addBuff(new boilingBlood());
                    }
                }
        );
    }

    @Override
    public String getSkillId() { return "skill_endlessEdgeOfSpear"; }

}

